home *** CD-ROM | disk | FTP | other *** search
/ FishMarket 1.0 / FishMarket v1.0.iso / fishies / 051-075 / disk_065 / pascaltoc / p2c.c < prev    next >
C/C++ Source or Header  |  1992-05-06  |  11KB  |  418 lines
  1. /*----------------------------------------------------------------------
  2.   PAS2C.C  Version 1.1
  3.   Translate Pascal keywords and operators to C.
  4.   useage:  pas2c < pascal_source  > c_source
  5.     i.e., this is a filter program which filters out the Pascal.
  6.   By James A Mullens <jcm@ornl-msr.arpa>    29-Jan-87
  7.  
  8.   Revisions:
  9.     Version 1.1  17-Feb-87  Changed several keyword translations on the
  10.     advice of James R. Van Zandt <jrv@mitre-bedford.ARPA>.  Added many
  11.     more translations.  Added a source for function strcmpi for the
  12.     unfortunates who don't have this case-insensitive string comparison
  13.     in their C library.
  14.  
  15.     Dan Kegel     15 Mar 87    Made it work on Sun workstation.  Ripped out
  16.     translations that hurt translation of a large (20,000 line) Turbo program.
  17. ----------------------------------------------------------------------*/
  18.  
  19. #include <stdio.h>    /* standard I/O */
  20. #include <ctype.h>    /* character macros */
  21. #include <string.h>    /* string functions */
  22. #include "p2c.h"
  23. #include "ktypes.h"    /* keyword type definitions */
  24.  
  25. token cTok;        /* current token from scanner */
  26. boolean WasSemi;    /* kludge to avoid duplicating semicolons */
  27.  
  28. /* Change these translations to fit your desires, but the Pascal names must 
  29.    be written in lower case and must be in alphabetical order.  If you include 
  30.    a C comment in your translation output as a HINT to the programmer, write 
  31.    it in CAPITALs, else write the comment in lower case, eh?
  32. */
  33.  
  34. wnode xlate[] = {
  35.   {T_ZIP,    "and",        "&&"    },
  36.   {T_ARRAY,    "array",    ""    },    /* see parseTypeDecl */
  37.   {T_BEGIN,    "begin",    "{"    },
  38.   {T_ZIP,    "boolean",    "boolean"},
  39.   {T_ZIP,    "byte",        "char"    },    /* Turbo */
  40.   {T_CASE,    "case",        "switch"},
  41.   {T_CONST,    "const",    "/* CONST */"},
  42.   {T_ZIP,    "div",        "/"    },
  43.   {T_ZIP,    "do",        ")"    },
  44.   {T_ZIP,    "downto",    ";/*DOWNTO*/"},
  45.   {T_ZIP,    "else",        "; else"},
  46.   {T_END,    "end",        "}"    },
  47.   {T_ZIP,    "false",    "FALSE"    },    
  48.   {T_FILE,    "file",        ""    },    /* see parseTypeDecl() */
  49.   {T_ZIP,    "for",        "for ("    },
  50.   {T_FORWARD,    "forward",    ""    },
  51.   {T_FUNC,    "function",    ""    },    /* see parseProcedure() */
  52.   {T_ZIP,    "if",        "if ("    },
  53.   {T_ZIP,    "implementation", "/* private (static) section */"},
  54.   {T_ZIP,    "input",    "stdin"    },
  55.   {T_ZIP,    "integer",    "int"    },
  56.   {T_ZIP,    "interface",    "/* exported symbol section */"},
  57.   {T_ZIP,    "ioresult",    "errno"    },    /* UCSD, Turbo */
  58.   {T_LABEL,    "label",    ""    },    /* see parseLabel() */
  59.   {T_ZIP,    "mod",        "%"    },
  60.   {T_ZIP,    "not",        "!"    },
  61.   {T_OF,    "of",        ""    },    /* see parseTypeDecl() */
  62.   {T_ZIP,    "or",        "||"    },
  63.   {T_ZIP,    "output",    "stdout"},
  64.   {T_ZIP,    "packed",    "/* PACKED */"},
  65.   {T_PROC,    "procedure",    "void"    },    /* see parseProcedure() */
  66.   {T_ZIP,    "program",    "main"    },
  67.   {T_ZIP,    "read",        "scanf"    },
  68.   {T_ZIP,    "readln",    "/*LINE*/scanf"},/* hint - read end-of-line */
  69.   {T_ZIP,    "real",        "double"},    /* or "float" */
  70.   {T_RECORD,    "record",    ""    },    /* see parseTypeDecl() */
  71.   {T_ZIP,    "repeat",    "do {"    },
  72.   {T_STRINGTYPE,"string",    ""    },    /* UCSD, Turbo string type */
  73.   {T_ZIP,    "text",        "FILE *"},    /* UCSD, Turbo file type */
  74.   {T_ZIP,    "then",        ")"    },
  75.   {T_ZIP,    "to",        ";"    },
  76.   {T_ZIP,    "true",        "TRUE"    },    
  77.   {T_TYPE,    "type",        ""    },    /* see parseType() */
  78.   {T_ZIP,    "until",    "} until ("},
  79.   {T_ZIP,    "uses",        "/* USES */\n#include"},
  80.   {T_VAR,    "var",        "/* VAR */"},    /* see parseProc, parseVar() */
  81.   {T_ZIP,    "while",    "while ("},
  82.   {T_ZIP,    "with",        "/* WITH */"},    /*hint-set pointer to struct*/
  83.   {T_ZIP,    "write",    "printf"},
  84.   {T_ZIP,    "writeln",    "/*LINE*/printf"},/* hint - write newline */
  85.   {T_ZIP,    "",        ""    }    /* marks end of xlate table */
  86. };
  87.  
  88. wnode theend = {T_ZIP,    "", ""};
  89.  
  90. wnode *hash[26];        /* quick index into the translation array */
  91.  
  92. /* Fill in the quick index ("hash") array 
  93. */
  94. void init_hash()
  95. {
  96.     int ch, cmp;
  97.     wnode *nptr = xlate;
  98.  
  99.     for (ch='a'; ch<='z'; ch++) {
  100.     while (nptr->pname[0] && (cmp = ch - *nptr->pname) > 0) 
  101.         nptr++;
  102.     hash[ch-'a'] = (cmp==0) ? nptr : &theend;
  103.     }
  104. }
  105.  
  106.  
  107. /* compare two strings without regard to case,
  108.    the equivalent of this function may already be in your C library 
  109.    Used to fail on Suns because it used tolower on lowercase chars...
  110.    Assumes second argument already lowercase.
  111. */
  112. int strcmpi(s1,s2)
  113.     register char *s1, *s2;
  114. { 
  115.     register char c1;
  116.  
  117.     while ((c1= *s1++) && *s2) {    /* get char, advance ptr */
  118.     if (isupper(c1)) c1 = tolower(c1);
  119.     if (c1 != *s2) break;
  120.     s2++;
  121.     }
  122.     return(c1 - *s2);
  123. }
  124.  
  125.  
  126. /* Pass an identifier through the translation table; return its
  127.    keyword type.  Translated keyword left in same buffer.
  128. */
  129. int
  130. translate(word)
  131.     register char *word;
  132. { 
  133.     register wnode *xptr;
  134.     int nomatch;
  135.     int c;
  136.  
  137.     c = *word;
  138.     if (isalpha(c)) {
  139.     if (isupper(c)) c=tolower(c);
  140.     xptr = hash[c - 'a'];
  141.     while ( xptr->pname[0] && (nomatch = strcmpi(word,xptr->pname)) > 0 ) 
  142.         xptr++;
  143.     if (!nomatch) {
  144.         word[0]=0;
  145.         if (!WasSemi && xptr->ktype == T_END)
  146.         strcpy(word, ";");
  147.         strcat(word, xptr->cname);
  148.         return(xptr->ktype);
  149.     }
  150.     }
  151.     return(T_ZIP);
  152. }
  153.  
  154. #define Q_NOQUOTE  1
  155. #define Q_ONEQUOTE 2
  156. #define Q_DONE     3
  157. #define Q_ERR      4
  158.  
  159. #define Q_C_ESCAPES  FALSE   /* Set true if your Pascal knows backslashes */
  160.  
  161. /*---- parseQuotedString -------------------------------------------------
  162. Accepts Pascal quoted string from stdin, converts to C quoted string, and 
  163. places in buf.
  164. Examples:
  165.   'hi' -> "hi"    'hi''' -> "hi'"  'hi''''' -> "hi''"
  166.   ''   -> ""      ''''   -> "'"    ''''''   -> "''"
  167.   ''hi' -> ERROR  '''hi' -> "'hi"  '''''hi' -> "''hi"
  168.   'I''m'  -> "I'm"
  169. Double quotes and backslashes are preceded with backslashes, except that
  170. if Q_C_ESCAPES is TRUE, backslashes are left naked.
  171. --------------------------------------------------------------------------*/
  172. void
  173. parseQuotedString(buf)
  174. char *buf;
  175. {
  176.     register char c;
  177.     register char *letter=buf;
  178.     int qstate;
  179.  
  180.     *letter++ = '"';
  181.     qstate = Q_NOQUOTE;
  182.     while (qstate < Q_DONE) {
  183.     switch (c=getchar()) {
  184.     case '\'':
  185.         switch (qstate) {
  186.         case Q_NOQUOTE:  
  187.         qstate = Q_ONEQUOTE; break;
  188.         case Q_ONEQUOTE: 
  189.         *letter++ = c; qstate = Q_NOQUOTE; break;
  190.         }
  191.         break;
  192.     case EOF:
  193.     case '\n':
  194.         qstate= (qstate==Q_ONEQUOTE) ? Q_DONE : Q_ERR;
  195.         ungetc(c,stdin);
  196.         break;
  197.     default:
  198.         switch (qstate) {
  199.         case Q_ONEQUOTE: 
  200.         ungetc(c,stdin); qstate = Q_DONE; break;
  201.         case Q_NOQUOTE:
  202.         if (c=='\\' && !Q_C_ESCAPES) *letter++ = c;
  203.         if (c=='"') *letter++ = '\\';
  204.         *letter++ = c; 
  205.         break; 
  206.         }
  207.     }
  208.     }
  209.     *letter++ = '"';
  210.     *letter++ = '\0';
  211.     if (qstate == Q_ERR) {
  212.     fprintf(stderr,"Newline in string constant: %s\n",buf);
  213.     fprintf(stdout," %c*** \\n IN STRING ***%c ",
  214.         '/', buf, '/');
  215.     }
  216. }
  217.  
  218. void
  219. getTok()
  220. {
  221.     register char *letter = cTok.str;
  222.     register char *sEnd = letter + MAXTOKLEN-3;
  223.     register int c;
  224.  
  225.     c = getchar();
  226.     if (isalnum(c)) {
  227.     while (c != EOF && isalnum(c)) {
  228.         *letter++ = c;
  229.         c = getchar();
  230.     }
  231.     ungetc(c,stdin);
  232.     *letter++ = 0;
  233.     cTok.kind = translate(cTok.str);
  234.     } else {
  235.     switch(c) {
  236.     case '\n':    /* newline */
  237.     case 0x20:    /* space */
  238.     case 0x9:    /* tab */
  239.         do        /* Gather a string of blank space into one token */
  240.         *letter++ = c;
  241.         while ((c=getchar()) != EOF && isspace(c));
  242.         ungetc(c, stdin);
  243.         *letter++ = '\0';
  244.         cTok.kind = T_SPACE;
  245.         break;
  246.     case '\'':                 /* Quoted String */
  247.         parseQuotedString(cTok.str);
  248.         cTok.kind = T_STRING;
  249.         break;
  250.     case '{' :                 /* Curly Comment */
  251.         *letter++='/'; 
  252.         *letter++='*';
  253.         while ((c=getchar()) != EOF && c!='}' && letter!=sEnd)
  254.         *letter++ = c;
  255.         if (letter == sEnd) {
  256.         printf("/***ERROR: Comment too long (sorry) ***/");
  257.         while ((c=getchar()) != EOF && c!='}')
  258.             ;
  259.         }
  260.         strcpy(letter, "*/");
  261.         cTok.kind = T_COMMENT;
  262.         break;
  263.     case '(' : 
  264.         if ((c=getchar())!='*') {        /* Parenthesis */
  265.         ungetc(c,stdin);
  266.         strcpy(letter, "(");
  267.         cTok.kind = T_LPAREN;
  268.         } else {
  269.         register int lastc = '\0';    /* (* Comment *) */
  270.         *letter++='/'; 
  271.         *letter++='*';
  272.         while ((c=getchar())!=EOF && !(c==')' && lastc == '*') && 
  273.             letter != sEnd) {
  274.             lastc = c;
  275.             *letter++ = c;
  276.         }
  277.         if (letter == sEnd) {
  278.             printf("/***ERROR: Comment too long (sorry) ***/");
  279.             while ((c=getchar())!=EOF && !(c==')' && lastc == '*'))
  280.             lastc = c;
  281.         }
  282.         strcpy(letter, "/");        /* * already there! */
  283.         cTok.kind = T_COMMENT;
  284.         }
  285.         break;
  286.     case ')' :
  287.         strcpy(letter, ")");
  288.         cTok.kind = T_RPAREN;
  289.         break;
  290.     case ':' : 
  291.         if ((c=getchar())=='=') {        /* Assignment */
  292.         strcpy(letter, "=");
  293.         cTok.kind = T_ASSIGN;
  294.         } else {                /* Colon */
  295.         ungetc(c,stdin);
  296.         strcpy(letter, ":");
  297.         cTok.kind = T_COLON;
  298.         }
  299.         break;
  300.     case '=':
  301.         strcpy(letter, "==");        /* Might be equality test...*/
  302.         cTok.kind = T_EQUALS;        /* depends on parse state */
  303.         break;
  304.     case '<' : 
  305.         switch (c=getchar()) {
  306.         case '>':  
  307.         strcpy(letter, "!=");
  308.         break;
  309.         case '=':  
  310.         strcpy(letter, "<=");
  311.         break;
  312.         default :  
  313.         ungetc(c,stdin);
  314.         strcpy(letter,"<");
  315.         }
  316.         cTok.kind = T_COMPARE;
  317.         break;
  318.     case '>' : 
  319.         if ((c=getchar()) == '=')
  320.         strcpy(letter, ">=");
  321.         else {
  322.         ungetc(c,stdin);
  323.         strcpy(letter, ">");
  324.         }
  325.         cTok.kind = T_COMPARE;
  326.         break;
  327.     case '^' :
  328.         if ((c=getchar()) == '.') {    /* perhaps we should skip blanks? */
  329.         strcpy(letter, "->");
  330.         cTok.kind = T_STRUCTMEMBER;
  331.         } else {
  332.         ungetc(c,stdin);
  333.         strcpy(letter, "[0]");    /* '*' would have to go in front */
  334.         cTok.kind = T_DEREF;
  335.         }
  336.         break;
  337.     case '$' :            /* Turbo Pascal extension */ 
  338.         strcpy(letter, "0x");
  339.         cTok.kind = T_ZIP;
  340.         break;
  341.     case ';' :             /* Semicolon- translation depends on */
  342.         strcpy(letter, ";");    /* parse state... */
  343.         cTok.kind = T_SEMI;
  344.         break;
  345.     case '.':
  346.         if ((c=getchar()) == '.') {
  347.         cTok.kind = T_RANGE;
  348.         letter[0]=0;
  349.         } else {
  350.         ungetc(c,stdin);
  351.         strcpy(letter, ".");
  352.         cTok.kind = T_ZIP;
  353.         }
  354.         break;
  355.     case '[':
  356.         *letter++ = c; *letter = '\0';
  357.         cTok.kind = T_LBRACKET;
  358.         break;
  359.     case ']':
  360.         *letter++ = c; *letter = '\0';
  361.         cTok.kind = T_RBRACKET;
  362.         break;
  363.     case ',':
  364.         *letter++ = c; *letter = '\0';
  365.         cTok.kind = T_COMMA;
  366.         break;
  367.     case EOF:            /* end of file */
  368.         cTok.kind = T_EOF;
  369.         break;
  370.     default: 
  371.         *letter++ = c;        /* Pass unknown chars thru as tokens */
  372.         *letter = '\0';
  373.         cTok.kind = T_ZIP;
  374.     }
  375.     }
  376. }
  377.  
  378. main(argc, argv)
  379. int argc;
  380. char **argv;
  381. {
  382.     int debug;
  383.     
  384.     debug = (argc > 1);
  385.     init_hash();
  386.     WasSemi = FALSE;
  387.  
  388.     getTok(); 
  389.     do {
  390.     switch(cTok.kind) {
  391.     case T_VAR:
  392.         parseVar();
  393.         break;
  394.     case T_PROC:
  395.     case T_FUNC:
  396.         parseProcedure();
  397.         break;
  398.     case T_LABEL:
  399.         parseLabel();
  400.         break;
  401.     case T_TYPE:
  402.         parseType();
  403.         break;
  404.     default:
  405.         if (debug)
  406.         printf("'%s' %d\n", cTok.str, cTok.kind);
  407.         else {    /* fancy stuff to avoid duplicating semicolons */
  408.         if (cTok.kind != T_SEMI || !WasSemi)
  409.             fputs(cTok.str, stdout);
  410.         if (cTok.kind != T_SPACE && cTok.kind != T_COMMENT)
  411.             WasSemi = (cTok.kind == T_SEMI);
  412.         }
  413.         getTok();
  414.     }
  415.     } while (cTok.kind != T_EOF);
  416. }
  417.  
  418.